import axios from 'axios'

// 创建单独的axios实例用于认证API
// 使用相对路径，通过vue.config.js中的代理配置转发请求
const authApi = axios.create({
  baseURL: '/api',
  timeout: 30000,
  headers: {
    'Content-Type': 'application/json'
  }
})

function getTokenExpiration(token) {
  try {
    // 首先验证token的基本格式
    if (!token || typeof token !== 'string') {
      console.log('Token无效或为空，清除localStorage...')
      localStorage.removeItem('token')
      localStorage.removeItem('user')
      return null
    }
    
    // 分割token检查是否为有效的JWT格式（应该有3个部分）
    const tokenParts = token.split('.')
    if (tokenParts.length !== 3) {
      console.log(`JWT token格式错误，应该有3个部分，实际有${tokenParts.length}个部分`)
      console.log('Token预览:', token.substring(0, 50) + '...')
      console.log('清除无效的token...')
      localStorage.removeItem('token')
      localStorage.removeItem('user')
      return null
    }
    
    // 解码JWT token
    console.log('开始解码JWT token...')
    console.log('Token长度:', token.length)
    console.log('Token前20个字符:', token.substring(0, 20) + '...')
    
    // 后端生成标准base64格式的token，直接解码payload部分
    // payload是tokenParts[1]
    const payloadBase64 = tokenParts[1]
    console.log('Payload base64:', payloadBase64)
    
    // 添加必要的padding（标准base64需要）
    let paddedBase64 = payloadBase64
    while (paddedBase64.length % 4 !== 0) {
      paddedBase64 += '='
    }
    console.log('添加padding后:', paddedBase64)
    
    // 解码payload
    const decodedPayload = atob(paddedBase64)
    console.log('解码后的payload长度:', decodedPayload.length)
    console.log('解码后的payload前100个字符:', decodedPayload.substring(0, 100))
    
    // 解析JSON
    const payload = JSON.parse(decodedPayload)
    console.log('解析后的payload内容:', payload)
    
    // 检查是否有过期时间
    if (!payload.exp) {
      console.log('Token中没有exp字段，清除localStorage...')
      localStorage.removeItem('token')
      localStorage.removeItem('user')
      return null
    }
    
    console.log('Token过期时间:', new Date(payload.exp * 1000).toLocaleString())
    return payload.exp * 1000
    
  } catch (error) {
    console.error('解码JWT token失败:', error.message)
    console.error('完整错误信息:', error)
    
    // 如果解码失败，可能token格式不正确，清除localStorage
    console.log('Token解码错误，清除localStorage...')
    localStorage.removeItem('token')
    localStorage.removeItem('user')
    
    return null
  }
}

// 检查token是否过期 - 优化版本，减少异常影响
const isTokenExpired = (token) => {
  try {
    // 如果token为空，直接返回未过期
    if (!token) {
      console.warn('Token为空，默认认为未过期')
      return false
    }
    
    const expiration = getTokenExpiration(token)
    
    // 如果无法解析token（返回null），默认认为未过期但记录日志
    if (!expiration) {
      console.warn('无法解析token，默认认为未过期:', token ? token.substring(0, 20) + '...' : 'null')
      return false
    }
    
    const isExpired = Date.now() > expiration
    if (isExpired) {
      console.log('Token已过期，过期时间:', new Date(expiration).toLocaleString())
    } else {
      console.log('Token有效，剩余时间:', Math.ceil((expiration - Date.now()) / 1000), '秒')
    }
    
    return isExpired
  } catch (error) {
    console.warn('检查token过期状态时出错，但不阻塞认证:', error.message)
    return false // 出错时不认为token过期，允许后续验证
  }
}

// 清除过期token
const clearExpiredToken = () => {
  const token = localStorage.getItem('token')
  if (token && isTokenExpired(token)) {
    console.log('Token已过期，自动清除')
    localStorage.removeItem('token')
    localStorage.removeItem('user')
    return true
  }
  return false
}

// 添加JWT认证拦截器
authApi.interceptors.request.use(
  config => {
    // 首先检查token是否过期
    if (clearExpiredToken()) {
      // 如果token已过期且正在请求需要认证的接口，取消请求
      if (config.url !== '/auth/login' && config.url !== '/auth/register') {
        console.warn('Token已过期，取消请求')
        return Promise.reject(new Error('Token已过期'))
      }
    }
    
    const token = localStorage.getItem('token')
    if (token) {
      config.headers.Authorization = `Bearer ${token}`
    }
    return config
  },
  error => {
    return Promise.reject(error)
  }
)

// 添加响应拦截器处理常见错误
authApi.interceptors.response.use(
  response => response,
  error => {
    // 处理401未授权错误
    if (error.response && error.response.status === 401) {
      console.error('认证失败，清除token')
      localStorage.removeItem('token')
      localStorage.removeItem('user')
      // 不在这里直接跳转，让路由守卫处理
    }
    return Promise.reject(error)
  }
)

/**
 * 认证服务模块 - 处理用户注册、登录、退出等功能
 */
export const authService = {
  // 用户注册
  register: async (userData) => {
    try {
      console.log('开始发送注册请求:', userData)
      // 使用authApi实例发送请求
      const response = await authApi.post('/auth/register', userData)
      console.log('注册请求响应:', response.data)
      
      // 统一处理成功响应
      if (response.data.data && response.data.data.token) {
        console.log('注册成功，存储token和用户信息')
        localStorage.setItem('token', response.data.data.token)
        
        // 构建标准化的用户信息对象
        const userInfo = {
          id: response.data.data.id,
          username: response.data.data.username,
          avatar: response.data.data.avatar || '',
          email: response.data.data.email,
          role: response.data.data.role || 'USER'
        }
        localStorage.setItem('user', JSON.stringify(userInfo))
        
        // 返回标准化的成功响应
        return {
          success: true,
          token: response.data.data.token,
          user: userInfo
        }
      } else {
        // 处理没有token的情况
        console.log('注册响应缺少token:', response.data)
        return {
          success: false,
          error: 'registration_incomplete',
          message: '注册成功但缺少必要信息，请重新登录'
        }
      }
    } catch (error) {
      console.error('注册错误:', error)
      
      // 统一错误处理和响应格式
      let errorMessage = '注册过程中发生错误'
      let errorType = 'registration_failed'
      
      if (error.response) {
        console.error('响应错误状态:', error.response.status)
        console.error('响应错误数据:', error.response.data)
        
        // 根据不同状态码提供更具体的错误信息
        if (error.response.status === 409) {
          errorMessage = '该用户名或邮箱已被注册'
          errorType = 'user_exists'
        } else if (error.response.status === 400) {
          errorMessage = error.response.data.message || '输入信息有误，请检查'
          errorType = 'invalid_input'
        } else if (error.response.status === 500) {
          errorMessage = '服务器内部错误，请稍后重试'
          errorType = 'server_error'
        } else if (error.response.status === 401) {
          errorMessage = '认证失败，请检查输入信息'
          errorType = 'authentication_failed'
        }
      } else if (error.request) {
        console.error('请求发送但未收到响应:', error.request)
        errorMessage = '无法连接到服务器，请检查网络连接'
        errorType = 'network_error'
      } else {
        console.error('请求配置错误:', error.message)
      }
      
      // 返回标准化的错误响应
      return {
        success: false,
        error: errorType,
        message: errorMessage,
        originalError: error.message // 可选，用于调试
      }
    }
  },

  // 用户登录 - 优化版本
  login: async (credentials) => {
    try {
      console.log('开始登录请求:', credentials.username ? { username: credentials.username } : credentials)
      
      // 清除可能存在的过期token
      clearExpiredToken()
      
      const response = await authApi.post('/auth/login', credentials)
      console.log('登录响应状态:', response.status)
      
      // 统一处理响应数据格式
      const responseData = response.data || {}
      console.log('后端返回的原始数据格式:', responseData)
      
      // 检查后端返回的token格式（ultra_simple_server返回嵌套结构）
      let token = null
      let userData = null
      
      // 检查嵌套结构: response.data.data.token
      if (responseData.data && responseData.data.token) {
        token = responseData.data.token
        userData = responseData.data
        console.log('✓ 使用嵌套结构格式获取token')
        console.log('✓ Token长度:', token.length)
        console.log('✓ 用户数据:', userData)
      }
      // 检查扁平结构: response.data.token (FastAPI格式)
      else if (responseData.token) {
        token = responseData.token
        userData = responseData
        console.log('✓ 使用扁平结构格式获取token')
        console.log('✓ Token长度:', token.length)
        console.log('✓ 用户数据:', userData)
      }
      // 检查备用格式: response.data.access_token
      else if (responseData.access_token) {
        token = responseData.access_token
        userData = responseData
        console.log('✓ 使用备用格式获取token')
        console.log('✓ Token长度:', token.length)
        console.log('✓ 用户数据:', userData)
      }
      else {
        console.error('❌ 后端响应中未找到token')
        console.error('❌ 响应数据结构检查:')
        console.error('  - responseData:', typeof responseData, responseData)
        console.error('  - responseData.data存在:', !!responseData.data)
        console.error('  - responseData.token存在:', !!responseData.token)
        console.error('  - responseData.access_token存在:', !!responseData.access_token)
        if (responseData.data) {
          console.error('  - responseData.data.token存在:', !!responseData.data.token)
        }
        console.error('❌ 后端响应完整数据:', JSON.stringify(responseData, null, 2))
      }
      
      // 验证token是否存在
      if (token) {
        console.log('🔄 开始存储token和用户信息...')
        console.log('🔄 Token预览:', token.substring(0, 20) + '...')
        
        let userInfo = null
        
        // 增强型localStorage存储机制
        const storageResults = {
          tokenStored: false,
          userStored: false,
          errors: []
        }
        
        // 构建标准化的用户信息对象
        userInfo = {
          id: userData.userId || userData.id || null,
          username: userData.username || '',
          avatar: userData.avatar || '',
          email: userData.email || '',
          role: userData.role || 'USER'
        }
        console.log('🔄 用户信息对象:', userInfo)
        
        try {
          // 详细的localStorage环境检查
          console.log('🔍 localStorage环境检查开始')
          
          // 检查localStorage可用性
          const testKey = 'storage_test_' + Date.now()
          localStorage.setItem(testKey, 'test')
          const testValue = localStorage.getItem(testKey)
          localStorage.removeItem(testKey)
          console.log('🔍 localStorage可用性:', testValue === 'test')
          
          // 检查localStorage容量
          const initialLength = localStorage.length
          console.log('🔍 localStorage初始长度:', initialLength)
          
          // 检查localStorage总大小
          let totalSize = 0
          const keys = []
          for (let i = 0; i < localStorage.length; i++) {
            const key = localStorage.key(i)
            const value = localStorage.getItem(key)
            totalSize += (key.length + value.length) * 2 // UTF-16编码每个字符2字节
            keys.push(key)
          }
          console.log('🔍 localStorage估算大小:', totalSize + ' 字节')
          console.log('🔍 localStorage现有键:', keys)
          
          // 强制存储token - 同步操作，确保立即执行
          try {
            console.log('🔄 准备存储token:', token ? 'Token存在' : 'Token为空')
            console.log('🔄 Token类型:', typeof token)
            console.log('🔄 Token长度:', token ? token.length : 0)
            
            localStorage.setItem('token', token)
            console.log('🔄 Token存储操作完成')
            
            const storedToken = localStorage.getItem('token')
            console.log('🔄 Token读取验证:', storedToken ? 'Token读取成功' : 'Token读取失败')
            
            if (storedToken === token) {
              console.log('✅ Token存储成功')
              storageResults.tokenStored = true
            } else {
              console.error('❌ Token存储验证失败')
              console.error('❌ 预期Token:', token.substring(0, 20) + '...')
              console.error('❌ 实际Token:', storedToken ? storedToken.substring(0, 20) + '...' : 'null')
              storageResults.errors.push('Token存储验证失败')
            }
          } catch (tokenError) {
            console.error('❌ Token存储异常:', tokenError)
            console.error('❌ 异常类型:', tokenError.name)
            console.error('❌ 异常消息:', tokenError.message)
            storageResults.errors.push(`Token存储失败: ${tokenError.message}`)
          }
          
          // 强制存储用户信息 - 同步操作，确保立即执行
          try {
            const userString = JSON.stringify(userInfo)
            console.log('🔄 准备存储user:', userString)
            console.log('🔄 User字符串长度:', userString.length)
            
            localStorage.setItem('user', userString)
            console.log('🔄 User存储操作完成')
            
            const storedUser = localStorage.getItem('user')
            console.log('🔄 User读取验证:', storedUser ? 'User读取成功' : 'User读取失败')
            
            if (storedUser === userString) {
              console.log('✅ User存储成功')
              storageResults.userStored = true
            } else {
              console.error('❌ User存储验证失败')
              console.error('❌ 预期User:', userString.substring(0, 100) + '...')
              console.error('❌ 实际User:', storedUser ? storedUser.substring(0, 100) + '...' : 'null')
              storageResults.errors.push('User存储验证失败')
            }
          } catch (userError) {
            console.error('❌ User存储异常:', userError)
            console.error('❌ 异常类型:', userError.name)
            console.error('❌ 异常消息:', userError.message)
            storageResults.errors.push(`User存储失败: ${userError.message}`)
          }
          
          // 详细诊断存储结果
          console.log('🔍 存储诊断报告:', storageResults)
          
          // 检查localStorage整体状态
          try {
            const localStorageLength = localStorage.length
            const localStorageKeys = []
            for (let i = 0; i < localStorageLength; i++) {
              localStorageKeys.push(localStorage.key(i))
            }
            console.log('🔍 localStorage状态检查:', {
              length: localStorageLength,
              keys: localStorageKeys,
              hasToken: !!localStorage.getItem('token'),
              hasUser: !!localStorage.getItem('user')
            })
          } catch (statusError) {
            console.error('❌ localStorage状态检查失败:', statusError)
          }
          
          if (!storageResults.tokenStored || !storageResults.userStored) {
            console.error('❌ localStorage存储部分失败!')
            console.error('❌ 存储详情:', JSON.stringify(storageResults, null, 2))
            
            // 尝试使用备用的存储方案（sessionStorage）
            try {
              console.log('🔧 尝试使用备用存储方案 - sessionStorage')
              sessionStorage.setItem('token', token)
              sessionStorage.setItem('user', JSON.stringify(userInfo))
              console.log('✅ 备用存储方案成功')
            } catch (backupError) {
              console.error('❌ 备用存储方案也失败:', backupError)
            }
            
            return {
              success: false,
              error: 'storage_failed',
              message: `登录数据存储失败: ${storageResults.errors.join(', ')}`
            }
          }
          
        } catch (storageError) {
          console.error('❌ localStorage操作出错:', storageError)
          return {
            success: false,
            error: 'storage_error',
            message: '浏览器存储失败，请检查浏览器设置'
          }
        }
        
        // 返回标准化的成功响应
        return {
          success: true,
          token: token,
          user: userInfo
        }
      } else {
        // 处理没有token的情况
        console.warn('登录响应缺少token:', responseData)
        console.error('后端响应完整数据:', JSON.stringify(responseData, null, 2))
        return {
          success: false,
          error: 'login_incomplete',
          message: '登录失败，请检查用户名和密码'
        }
      }
    } catch (error) {
      console.error('登录错误:', error)
      
      // 统一错误处理和响应格式
      let errorMessage = '用户名或密码错误'
      let errorType = 'login_failed'
      
      if (error.response) {
        console.error('响应错误状态:', error.response.status)
        console.error('响应错误数据:', error.response.data)
        
        // 根据不同状态码提供更具体的错误信息
        if (error.response.status === 401) {
          errorMessage = '用户名或密码错误'
          errorType = 'invalid_credentials'
        } else if (error.response.status === 403) {
          errorMessage = '账户已被禁用'
          errorType = 'account_disabled'
        } else if (error.response.status === 500) {
          errorMessage = '服务器内部错误，请稍后重试'
          errorType = 'server_error'
        }
      } else if (error.request) {
        console.error('请求发送但未收到响应:', error.request)
        errorMessage = '无法连接到服务器，请检查网络连接'
        errorType = 'network_error'
      } else if (error.message === 'Token已过期') {
        errorMessage = '登录已过期，请重新登录'
        errorType = 'token_expired'
      }
      
      // 返回标准化的错误响应
      return {
        success: false,
        error: errorType,
        message: errorMessage,
        originalError: error.message // 可选，用于调试
      }
    }
  },

  // 退出登录
  logout: async () => {
    console.log('执行退出登录操作')
    try {
      // 调用后端退出登录接口
      const response = await authApi.post('/auth/logout')
      console.log('后端退出登录响应:', response.data)
    } catch (error) {
      console.error('后端退出登录失败:', error)
      console.log('错误详情:', error.response?.data, '状态码:', error.response?.status)
      // 即使后端接口失败，也要清除本地存储
    } finally {
      // 清除本地存储的token和用户信息
      localStorage.removeItem('token')
      localStorage.removeItem('user')
      console.log('本地存储已清除')
    }
    return { success: true }
  },

  // 获取当前用户信息 - 优化版本
  getCurrentUser: async () => {
    try {
      console.log('开始获取当前用户信息')
      
      // 首先检查并清除过期token
      if (clearExpiredToken()) {
        console.log('Token已过期，无法获取用户信息')
        return null
      }
      
      // 检查是否有token，如果没有直接返回null
      if (!localStorage.getItem('token')) {
        console.log('没有找到token，用户未登录')
        return null
      }
      
      // 先从localStorage获取缓存的用户信息
      const cachedUser = localStorage.getItem('user')
      if (cachedUser) {
        try {
          const userData = JSON.parse(cachedUser)
          console.log('从缓存获取用户信息成功')
          
          // 验证缓存的用户信息是否完整
          if (userData && userData.username) {
            return userData
          } else {
            console.warn('缓存的用户数据不完整，需要刷新')
            localStorage.removeItem('user')
          }
        } catch (e) {
          console.warn('缓存的用户数据无效，尝试从服务器获取')
          localStorage.removeItem('user')
        }
      }
      
      try {
        // 如果缓存不存在、不完整或解析失败，从服务器获取
        const response = await authApi.get('/auth/me')
        console.log('从服务器获取用户信息成功:', response.status)
        
        // 处理服务器返回的数据格式
        const serverResponse = response.data || {}
        const serverUserData = serverResponse.user || serverResponse
        
        // 验证服务器返回的数据
        if (!serverUserData || !serverUserData.id && !serverUserData.userId) {
          console.warn('服务器返回的用户数据不完整:', serverUserData)
          return null
        }
        
        // 构建标准化的用户信息对象
        const userInfo = {
          id: serverUserData.id || serverUserData.userId || null,
          username: serverUserData.username || '',
          avatar: serverUserData.avatar || '',
          email: serverUserData.email || '',
          // 确保角色信息正确处理，兼容不同的大小写形式
          role: serverUserData.role || serverUserData.Role || 'USER'
        }
        
        // 更新缓存
        localStorage.setItem('user', JSON.stringify(userInfo))
        console.log('用户信息已更新到缓存')
        return userInfo
      } catch (serverError) {
        // 处理服务器请求失败的情况
        console.error('从服务器获取用户信息失败:', serverError)
        
        // 如果是401错误，清除token并返回null
        if (serverError.response && serverError.response.status === 401) {
          console.error('认证失败，清除token')
          localStorage.removeItem('token')
          localStorage.removeItem('user')
          return null
        }
        
        // 如果缓存已删除且服务器请求失败，返回null
        if (!localStorage.getItem('user')) {
          return null
        }
        
        // 如果还有缓存，尝试再次使用缓存
        try {
          const lastChanceUser = JSON.parse(localStorage.getItem('user'))
          console.log('使用最后可用的用户缓存信息')
          return lastChanceUser
        } catch (e) {
          console.warn('最后的用户缓存也无效')
          localStorage.removeItem('user')
          return null
        }
      }
    } catch (error) {
      console.error('获取当前用户信息时发生未预期的错误:', error)
      
      // 出错时确保清除可能无效的token
      try {
        localStorage.removeItem('token')
        localStorage.removeItem('user')
      } catch (cleanupError) {
        console.error('清除无效token时出错:', cleanupError)
      }
      
      return null
    }
  },

  // 检查是否已登录 - 优化版本，包含token过期检查
  isAuthenticated: () => {
    try {
      // 首先检查token是否存在
      const token = localStorage.getItem('token')
      if (!token) {
        console.log('未找到token，登录状态为：未登录')
        return false
      }
      
      // 尝试检查token是否过期，但不阻塞认证
      try {
        const expiration = getTokenExpiration(token)
        if (expiration && Date.now() > expiration) {
          console.log('Token已过期，清除登录状态')
          localStorage.removeItem('token')
          localStorage.removeItem('user')
          return false
        }
      } catch (expError) {
        // 解析token失败时，不阻止认证，只记录警告
        console.warn('Token解析失败，但允许认证继续:', expError.message)
      }
      
      // 检查用户信息是否存在
      const userJson = localStorage.getItem('user')
      if (!userJson) {
        console.log('未找到用户信息，登录状态为：未登录')
        return false
      }
      
      // 尝试解析用户信息
      try {
        const user = JSON.parse(userJson)
        if (user && user.username) {
          console.log('认证检查通过，用户已登录:', user.username)
          return true
        } else {
          console.log('用户信息无效，登录状态为：未登录')
          localStorage.removeItem('user')
          return false
        }
      } catch (userError) {
        console.log('用户信息解析失败，登录状态为：未登录')
        localStorage.removeItem('user')
        return false
      }
    } catch (error) {
      console.error('认证检查过程中发生错误:', error)
      // 出错时清除可能的无效数据
      try {
        localStorage.removeItem('token')
        localStorage.removeItem('user')
      } catch (cleanupError) {
        console.error('清除localStorage失败:', cleanupError)
      }
      return false
    }
  },

  // 检查用户是否是管理员
  isAdmin: async function() {
    try {
      // 从localStorage直接获取用户信息，确保及时反映最新状态
      const userJson = localStorage.getItem('user');
      if (!userJson) {
        // 如果localStorage没有用户信息，尝试从服务器获取
        const user = await this.getCurrentUser();
        const result = user && user.role === 'ADMIN';
        console.log('检查管理员权限:', result ? '是管理员' : '不是管理员');
        return result;
      }
      
      const user = JSON.parse(userJson);
      const result = user && (user.role === 'ADMIN' || user.role === 'admin');
      console.log('检查管理员权限:', result ? '是管理员' : '不是管理员', '角色:', user.role);
      return result;
    } catch (error) {
      console.error('检查管理员权限时发生错误:', error);
      return false;
    }
  },

  // 检查权限
  hasPermission: async function(requiredPermission) {
    const user = await this.getCurrentUser();
    if (!user) {
      console.log('未登录用户，无权限');
      return false;
    }
    
    // 管理员拥有所有权限
    if (user.role === 'ADMIN') {
      console.log('管理员用户拥有所有权限');
      return true;
    }
    
    // 普通用户的权限检查
    const userPermissions = {
      'USER': ['view_own_rooms', 'send_messages', 'create_rooms']
    };
    
    const hasPerm = userPermissions[user.role]?.includes(requiredPermission) || false;
    console.log(`用户权限检查 - 角色: ${user.role}, 所需权限: ${requiredPermission}, 结果: ${hasPerm}`);
    return hasPerm;
  }
}